package com.piece.core.jpa.repository;

import com.piece.core.jpa.support.JpaQuery;
import com.piece.core.framework.support.bootstrap.DataTable;
import com.piece.core.framework.support.bootstrap.Order;
import com.piece.core.framework.support.bootstrap.QueryTable;
import org.springframework.data.repository.NoRepositoryBean;
import java.io.Serializable;
import java.util.List;
import java.util.Map;

@NoRepositoryBean
public interface IBaseRepository<T, ID extends Serializable> {

    /**
     * 获取实体类型
     */
    Class<T> getEntityClass();

    /**
     * 插入记录
     */
    T insert(T entity);

    /**
     * 批量插入
     */
    List<T> batchInsert(List<T> list);

    /**
     * 更新记录
     */
    void update(T entity);

    /**
     * 批量更新
     */
    void batchUpdate(List<T> list);

    /**
     * 更新非空属性记录
     */
    void updateNotNull(T entity);

    /**
     * 根据条件更新
     *
     * @param conditionName  条件属性名
     * @param conditionValue 条件属性值
     * @param propertyName   更新属性名
     * @param propertyValue  更新属性值
     */
    int updateByProperties(String conditionName, Object conditionValue, String propertyName, Object propertyValue);

    /**
     * 根据条件更新
     *
     * @param condition     条件属性
     * @param propertyName  更新属性名
     * @param propertyValue 更新属性值
     */
    int updateByProperties(Map<String, Object> condition, String propertyName, Object propertyValue);

    /**
     * 根据条件更新
     *
     * @param conditionName  条件属性名
     * @param conditionValue 条件属性值
     * @param property       更新属性
     */
    int updateByProperties(String conditionName, Object conditionValue, Map<String, Object> property);

    /**
     * 根据条件更新
     *
     * @param condition 条件属性
     * @param property  更新属性
     */
    int updateByProperties(Map<String, Object> condition, Map<String, Object> property);

    /**
     * 删除记录
     */
    void delete(T entity);

    /**
     * 批量删除
     */
    void batchDelete(List<T> list);

    /**
     * 删除记录
     */
    void delete(Serializable id);

    /**
     * 删除记录
     */
    int delete(Serializable[] ids);

    /**
     * 根据条件删除
     */
    int deleteByProperties(String propName, Object propValue);

    /**
     * 根据条件删除
     */
    int deleteByProperties(Map<String, Object> condition);

    /**
     * 根据id查询单条记录
     */
    T findById(Serializable id);

    /**
     * 根据条件查询单条记录
     */
    T findOneByCondition(Map<String, Object> condition);

    /**
     * 根据条件查询单条记录
     */
    T findOneByCondition(String sql, String alias, Map<String, Object> condition);

    /**
     * 根据主键查询记录
     */
    List<T> findByKeys(List<Long> keys);

    /**
     * 根据条件查询记录
     */
    List<T> findByConditionWithEntity(T entity, List<Order> orders);

    /**
     * 根据条件查询记录
     */
    List<T> findByCondition(String propName, Object propValue, List<Order> orders);

    /**
     * 根据条件查询记录
     */
    List<T> findByCondition(Map<String, Object> condition, List<Order> orders);

    /**
     * 根据条件查询记录
     */
    List<T> findByCondition(String sql, String alias, Map<String, Object> condition, List<Order> orders);

    /**
     * 分页查询
     */
    DataTable<T> findPage(QueryTable queryTable);

    /**
     * 分组分页查询
     */
    DataTable findPage(QueryTable queryTable, Class targetClass);

    /**
     * 分组查询
     */
    List findByGroup(QueryTable queryTable, Class targetClass);

    /**
     * 统计记录
     */
    Long count(String sql, List<Object> conditionValue, boolean isHql);

    /**
     * 统计记录
     */
    Long count(String sql, Object[] conditionValue, boolean isHql);

    /**
     * 根据query查找记录
     *
     * @param query       查询条件
     * @param firstResult 起始行
     * @param maxResults  结束行
     */
    <T extends Serializable> List<T> find(JpaQuery query, int firstResult, int maxResults);

    /**
     * 根据query查找记录
     *
     * @param query 查询条件
     */
    <T extends Serializable> List<T> find(JpaQuery query);

    /**
     * 根据hql查找记录
     *
     * @param hql    hql语句
     * @param params 查询条件
     */
    <T extends Serializable> List<T> find(String hql, Object[] params);

    /**
     * 根据hql查询指定数据
     *
     * @param hql         hql
     * @param firstResult 起始行
     * @param maxResults  结束行
     * @param params      查询条件
     */
    <T extends Serializable> List<T> find(String hql, int firstResult, int maxResults, Object[] params);

    /**
     * 查询全部记录
     */
    List findAll();

    /**
     * 查询全部记录
     *
     * @param clazz 实体类
     */
    List findAll(Class clazz);

    /**
     * 执行查询操作的sql语句
     */
    <T extends Serializable> List<T> findBySql(String sql, Object[] params);

    /**
     * 执行查询操作的sql语句
     *
     * @param sql         sql
     * @param firstResult 起始行
     * @param maxResults  结束行
     */
    <T extends Serializable> List<T> findBySql(String sql, int firstResult, int maxResults, Object[] params);

    /**
     * 执行查询操作的sql语句
     */
    List<Map> findBySqlToMap(String sql, Object[] params);

    /**
     * 执行查询操作的sql语句
     */
    List<Map> findBySqlToMap(String sql, Object[] params, int firstResult, int maxResults);

    /**
     * 查询记录
     *
     * @param clazz     要查询的实体类
     * @param condition 查询条件
     */
    List find(Class clazz, String condition);

    /**
     * 执行更新操作的sql语句
     */
    Integer executeSql(String sql);

    /**
     * 执行更新操作的sql语句
     */
    Integer executeSql(String sql, Object[] params);

    /**
     * 执行更新操作的hql语句
     */
    Integer executeHql(String hql);

    /**
     * 执行更新操作的hql语句
     */
    Integer executeHql(String hql, Object[] params);

    /**
     * 根据hql分页查询
     */
    DataTable<T> findPageByHql(QueryTable queryTable);

    /**
     * 根据sql分页查询
     */
    DataTable<T> findPageBySql(QueryTable queryTable);

    /**
     * 查询主键对象是否存在
     */
    boolean checkExist(Serializable id);

    /**
     * 查询主键对象是否存在
     */
    boolean checkExist(Serializable[] ids);

    void flush();

    void clear();
}
